// Machine generated IDispatch wrapper class(es) created with ClassWizard
/////////////////////////////////////////////////////////////////////////////
// IGxServer wrapper class
#pragma  once

typedef 
enum tagIUnderlyingType
{
	iutKospi200 = 0,
	iutKosdaq50 = 1,
	iutStock = 2,
	iutBond = 3,
	iutCurrency = 4,
	iutProduct = 5,
	iutNA = 100
} 	IUnderlyingType;

typedef 
enum tagISymbolType
{
	istIndex = 0,
	istStock = 1,
	istFuture = 2,
	istOption = 3,
	istCombi = 4,
	istBond = 5,
	istNA = 100
} 	ISymbolType;

typedef 
enum tagIOptionType
{
	iotCall = 0,
	iotPut = 1,
	iotNA = 100
} 	IOptionType;

typedef 
enum tagIPositionType
{
	iptLong = 0,
	iptShort = 1,
	iptNA = 100
} 	IPositionType;

typedef 
enum tagIChartDataType
{
	icdOHLC = 0,
	icdOpenInterest = 1,
	icdNA = 100
} 	IChartDataType;

typedef 
enum tagIChartBaseType
{
	icbTick = 0,
	icbMin = 1,
	icbDaily = 2,
	icbWeekly = 3,
	icbMonthly = 4,
	icbNA = 100
} 	IChartBaseType;

typedef 
enum tagIOrderType
{
	iotNew = 0,
	iotChange = 1,
	iotCancel = 2,
	iortNA = 100
} 	IOrderType;

typedef 
enum tagIFillType
{
	iftFAS = 2,
	iftIOC = 1,
	iftFOK = 0,
	iftNA = 100
} 	IFillType;

typedef 
enum tagIEmOrderType
{
	ieoLong = 0,
	ieoShort = 1,
	ieoChange = 2,
	ieoCancel = 3,
	ieoNA = 100
} 	IEmOrderType;

typedef 
enum tagIOrderReqStateType
{
	irsNew = 0,
	irsSendRjt = 1,
	irsSendWait = 2,
	irsSrvWait = 3,
	irsSrvRjt = 4,
	irsKseWait = 5,
	irsKseAcpt = 6,
	irsKseRjt = 7,
	irsNA = 100
} 	IOrderReqStateType;

typedef 
enum tagIOrderStateType
{
	iosKseAcpt = 0,
	iosDead = 1,
	iosFullFill = 2,
	iosPartFill = 3,
	iosConfirm = 4,
	iosNA = 100
} 	IOrderStateType;

typedef 
enum tagIPriceType
{
	iptPrice = 0,
	iptMarket = 1,
	iptCondition = 2,
	iptBestPrice = 3,
	iprtNA = 100
} 	IPriceType;

typedef 
enum tagIGreeksCalcType
{
	igcCalDate = 0,
	igcCalTime = 1,
	igcTrdDate = 2,
	igcTrdTime = 3,
	igcNA = 100
} 	IGreeksCalcType;

typedef
enum tagIOrderCondType
{
	iocNormal = 0,
	iocLossCut = 1,
	iocProfitCut = 2
} 	IOrderCondType;



class IGxServer : public COleDispatchDriver
{
public:
	IGxServer() {}		// Calls COleDispatchDriver default constructor
	IGxServer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxServer(const IGxServer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetLastMessage();
	LPDISPATCH GetServerInfo();
	LPDISPATCH GetTradeStore();
	LPDISPATCH GetSymbolStore();
	LPDISPATCH GetChartStore();
};
/////////////////////////////////////////////////////////////////////////////
// IGxServerInfo wrapper class

class IGxServerInfo : public COleDispatchDriver
{
public:
	IGxServerInfo() {}		// Calls COleDispatchDriver default constructor
	IGxServerInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxServerInfo(const IGxServerInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	BOOL GetConnected();
	double GetServerDate();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxServerInfoEvents wrapper class

class IGxServerInfoEvents : public COleDispatchDriver
{
public:
	IGxServerInfoEvents() {}		// Calls COleDispatchDriver default constructor
	IGxServerInfoEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxServerInfoEvents(const IGxServerInfoEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnDisconnected(LPDISPATCH aGxServerInfo);
};
/////////////////////////////////////////////////////////////////////////////
// IGxSymbolStore wrapper class

class IGxSymbolStore : public COleDispatchDriver
{
public:
	IGxSymbolStore() {}		// Calls COleDispatchDriver default constructor
	IGxSymbolStore(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxSymbolStore(const IGxSymbolStore& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
	LPDISPATCH GetStocks();
	LPDISPATCH GetSpreads();
	LPDISPATCH GetFutures();
	LPDISPATCH GetOptionMonths();
	LPDISPATCH GetK200Index();
	LPDISPATCH GetNearestFuture();
	LPDISPATCH GetNearestOptMonth();
	BOOL SetGreeksParam(long GreeksCalcType, double dUnderMixRatio, double dCallVol, double dPutVol);
	BOOL GetQuoteEventFiltered();
	void SetQuoteEventFiltered(BOOL bNewValue);
	long GetQuoteEventInterval();
	void SetQuoteEventInterval(long nNewValue);
	BOOL GetPriceEventFiltered();
	void SetPriceEventFiltered(BOOL bNewValue);
	long GetPriceEventInterval();
	void SetPriceEventInterval(long nNewValue);
	BOOL GetTickEventFiltered();
	void SetTickEventFiltered(BOOL bNewValue);
	long GetTickEventInterval();
	void SetTickEventInterval(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// IGxSymbols wrapper class

class IGxSymbols : public COleDispatchDriver
{
public:
	IGxSymbols() {}		// Calls COleDispatchDriver default constructor
	IGxSymbols(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxSymbols(const IGxSymbols& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxSymbol wrapper class

class IGxSymbol : public COleDispatchDriver
{
public:
	IGxSymbol() {}		// Calls COleDispatchDriver default constructor
	IGxSymbol(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxSymbol(const IGxSymbol& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetCode();
	CString GetDesc();
	CString GetKorDesc();
	CString GetEngDesc();
	long GetUnderlyingType();
	long GetSymbolType();
	long GetOptionType();
	double GetStrikePrice();
	CString GetClosingMonth();
	double GetMatureDate();
	long GetTrailingDays();
	long GetPointValue();
	double GetCDRate();
	double GetHighLimit();
	double GetLowLimit();
	double GetCBHigh();
	double GetCBLow();
	double GetBasePrice();
	// method 'GetLongThValues' not emitted because of invalid return type or parameter type
	// method 'GetShortThValues' not emitted because of invalid return type or parameter type
	VARIANT GetVLongThValues();
	VARIANT GetVShortThValues();
	long GetPrecision();
	BOOL GetIsNearest();
	BOOL GetIsATM();
	double GetIv();
	long GetPrevOpenInterest();
	double GetOpen();
	double GetHigh();
	double GetLow();
	double GetClose();
	double GetChange();
	long GetOpenInterest();
	long GetAccVolume();
	CY GetAccAmount();
	LPDISPATCH GetQuote();
	LPDISPATCH GetLastTick();
	BOOL GetCanOrder();
	CString GetLastMessage();
	double GetThPrice();
	double GetIv2();
	double GetDelta();
	double GetGamma();
	double GetTheta();
	double GetVega();
	double GetLamda();
	double GetIntrinsicValue();
	double GetTimeValue();
	long GetEventOmitCount();
};
/////////////////////////////////////////////////////////////////////////////
// IGxSymbolEvents wrapper class

class IGxSymbolEvents : public COleDispatchDriver
{
public:
	IGxSymbolEvents() {}		// Calls COleDispatchDriver default constructor
	IGxSymbolEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxSymbolEvents(const IGxSymbolEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnPriceChanged(LPDISPATCH aGxSymbol);
};
/////////////////////////////////////////////////////////////////////////////
// IGxQuote wrapper class

class IGxQuote : public COleDispatchDriver
{
public:
	IGxQuote() {}		// Calls COleDispatchDriver default constructor
	IGxQuote(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxQuote(const IGxQuote& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	double GetUpdateTime();
	// method 'GetPrices' not emitted because of invalid return type or parameter type
	// method 'GetQtys' not emitted because of invalid return type or parameter type
	// method 'GetCnts' not emitted because of invalid return type or parameter type
	// method 'GetQuotes' not emitted because of invalid return type or parameter type
	VARIANT GetVPrices();
	VARIANT GetVQtys();
	VARIANT GetVCnts();
	VARIANT GetVQuotes();
	double Price(long PositionType, long iIndex);
	long Qty(long PositionType, long iIndex);
	long Cnt(long PositionType, long iIndex);
	CString GetLastMessage();
	long GetEventOmitCount();
};
/////////////////////////////////////////////////////////////////////////////
// IGxQuoteEvents wrapper class

class IGxQuoteEvents : public COleDispatchDriver
{
public:
	IGxQuoteEvents() {}		// Calls COleDispatchDriver default constructor
	IGxQuoteEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxQuoteEvents(const IGxQuoteEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnQuoteChanged(LPDISPATCH aGxSymbol, LPDISPATCH aGxQuote);
};
/////////////////////////////////////////////////////////////////////////////
// IGxLastTick wrapper class

class IGxLastTick : public COleDispatchDriver
{
public:
	IGxLastTick() {}		// Calls COleDispatchDriver default constructor
	IGxLastTick(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxLastTick(const IGxLastTick& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	double GetTime();
	long GetLSType();
	double GetPrice();
	double GetVolume();
	double GetAccVolume();
	long GetOpenInterest();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxLastTickEvents wrapper class

class IGxLastTickEvents : public COleDispatchDriver
{
public:
	IGxLastTickEvents() {}		// Calls COleDispatchDriver default constructor
	IGxLastTickEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxLastTickEvents(const IGxLastTickEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnNewTick(LPDISPATCH aGxSymbol, LPDISPATCH aGxLastTick);
};
/////////////////////////////////////////////////////////////////////////////
// IGxOptionMonths wrapper class

class IGxOptionMonths : public COleDispatchDriver
{
public:
	IGxOptionMonths() {}		// Calls COleDispatchDriver default constructor
	IGxOptionMonths(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOptionMonths(const IGxOptionMonths& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxOptionMonth wrapper class

class IGxOptionMonth : public COleDispatchDriver
{
public:
	IGxOptionMonth() {}		// Calls COleDispatchDriver default constructor
	IGxOptionMonth(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOptionMonth(const IGxOptionMonth& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetMonthCode();
	CString GetMonthDesc();
	LPDISPATCH GetStrikePrices();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxStrikePrices wrapper class

class IGxStrikePrices : public COleDispatchDriver
{
public:
	IGxStrikePrices() {}		// Calls COleDispatchDriver default constructor
	IGxStrikePrices(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxStrikePrices(const IGxStrikePrices& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxStrikePrice wrapper class

class IGxStrikePrice : public COleDispatchDriver
{
public:
	IGxStrikePrice() {}		// Calls COleDispatchDriver default constructor
	IGxStrikePrice(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxStrikePrice(const IGxStrikePrice& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetLastMessage();
	LPDISPATCH GetCall();
	LPDISPATCH GetPut();
	double GetStrikePrice();
	CString GetStrikeDesc();
};
/////////////////////////////////////////////////////////////////////////////
// IGxTradeStore wrapper class

class IGxTradeStore : public COleDispatchDriver
{
public:
	IGxTradeStore() {}		// Calls COleDispatchDriver default constructor
	IGxTradeStore(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxTradeStore(const IGxTradeStore& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetAccounts();
	LPDISPATCH GetPositions();
	LPDISPATCH GetOrders();
	LPDISPATCH GetFills();
	LPDISPATCH GetConfirms();
	LPDISPATCH GetOrderHandler();
	LPDISPATCH GetEmHandler();
	CString GetLastMessage();
	void Synchronize();
};
/////////////////////////////////////////////////////////////////////////////
// IGxOrders wrapper class

class IGxOrders : public COleDispatchDriver
{
public:
	IGxOrders() {}		// Calls COleDispatchDriver default constructor
	IGxOrders(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOrders(const IGxOrders& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
	LPDISPATCH FindOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iKseAcptNo);
};
/////////////////////////////////////////////////////////////////////////////
// IGxOrderEvents wrapper class

class IGxOrderEvents : public COleDispatchDriver
{
public:
	IGxOrderEvents() {}		// Calls COleDispatchDriver default constructor
	IGxOrderEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOrderEvents(const IGxOrderEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnNewOrder(LPDISPATCH aGxOrder);
	void OnOrderUpdated(LPDISPATCH aGxOrder);
};
/////////////////////////////////////////////////////////////////////////////
// IGxOrder wrapper class

class IGxOrder : public COleDispatchDriver
{
public:
	IGxOrder() {}		// Calls COleDispatchDriver default constructor
	IGxOrder(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOrder(const IGxOrder& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetAccount();
	LPDISPATCH GetSymbol();
	LPDISPATCH GetPosition();
	long GetOrderType();
	long GetPositionType();
	long GetPriceType();
	long GetQty();
	long GetLnitQty();
	double GetPrice();
	long GetOrderState();
	long GetSrvAcptNo();
	long GetKseAcptNo();
	double GetKseAcptTime();
	long GetFillQty();
	double GetLastFillPrice();
	long GetUnFillQty();
	LPDISPATCH GetTargetOrder();
	long GetTargetSrvAcptNo();
	long GetTargetKseAcptNo();
	LPDISPATCH GetFills();
	LPDISPATCH GetConfirms();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxAccounts wrapper class

class IGxAccounts : public COleDispatchDriver
{
public:
	IGxAccounts() {}		// Calls COleDispatchDriver default constructor
	IGxAccounts(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxAccounts(const IGxAccounts& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
	LPDISPATCH FindAccount(LPCTSTR stDesc);
};
/////////////////////////////////////////////////////////////////////////////
// IGxAccountEvents wrapper class

class IGxAccountEvents : public COleDispatchDriver
{
public:
	IGxAccountEvents() {}		// Calls COleDispatchDriver default constructor
	IGxAccountEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxAccountEvents(const IGxAccountEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnAccountUpdated(LPDISPATCH aGxAccount);
};
/////////////////////////////////////////////////////////////////////////////
// IGxAccount wrapper class

class IGxAccount : public COleDispatchDriver
{
public:
	IGxAccount() {}		// Calls COleDispatchDriver default constructor
	IGxAccount(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxAccount(const IGxAccount& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetCode();
	CString GetHiphenedCode();
	CString GetDesc();
	BOOL GetAuthenticated();
	BOOL GetApplyBiasMargin();
	double GetDepositTotal();
	double GetDepositCash();
	double GetMarginTotal();
	double GetMarginCash();
	double GetLiquidTotal();
	double GetLiquidCash();
	double GetCommission();
	double GetDailyPL();
	double GetAccPL();
	double GetEvalPL();
	LPDISPATCH GetOrders();
	LPDISPATCH GetPositions();
	CString GetLastMessage();
	void ForceUpdate();
};
/////////////////////////////////////////////////////////////////////////////
// IGxPositions wrapper class

class IGxPositions : public COleDispatchDriver
{
public:
	IGxPositions() {}		// Calls COleDispatchDriver default constructor
	IGxPositions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxPositions(const IGxPositions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
	LPDISPATCH FindPosition(LPCTSTR stAccountCode, LPCTSTR stSymbolCode);
};
/////////////////////////////////////////////////////////////////////////////
// IGxPositionEvents wrapper class

class IGxPositionEvents : public COleDispatchDriver
{
public:
	IGxPositionEvents() {}		// Calls COleDispatchDriver default constructor
	IGxPositionEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxPositionEvents(const IGxPositionEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnNewPosition(LPDISPATCH aGxPosition);
	void OnPositionUpdated(LPDISPATCH aGxPosition);
	void OnEvalPLUpdated(LPDISPATCH aGxPosition);
};
/////////////////////////////////////////////////////////////////////////////
// IGxPosition wrapper class

class IGxPosition : public COleDispatchDriver
{
public:
	IGxPosition() {}		// Calls COleDispatchDriver default constructor
	IGxPosition(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxPosition(const IGxPosition& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetAccount();
	LPDISPATCH GetSymbol();
	long GetQty();
	long GetPrevQty();
	long GetTodayQty();
	double GetAvgPrice();
	double GetEvalPL();
	long GetShortOrderQty();
	long GetLongOrderQty();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxFills wrapper class

class IGxFills : public COleDispatchDriver
{
public:
	IGxFills() {}		// Calls COleDispatchDriver default constructor
	IGxFills(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxFills(const IGxFills& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxFillEvents wrapper class

class IGxFillEvents : public COleDispatchDriver
{
public:
	IGxFillEvents() {}		// Calls COleDispatchDriver default constructor
	IGxFillEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxFillEvents(const IGxFillEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnNewFill(LPDISPATCH aGxFill);
	void OnFillUpdated(LPDISPATCH aGxFill);
};
/////////////////////////////////////////////////////////////////////////////
// IGxFill wrapper class

class IGxFill : public COleDispatchDriver
{
public:
	IGxFill() {}		// Calls COleDispatchDriver default constructor
	IGxFill(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxFill(const IGxFill& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetOrder();
	long GetFillNo();
	long GetFillQty();
	double GetFillPrice();
	double GetFillTime();
	double GetNearPrice();
	double GetFarPrice();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxConfirms wrapper class

class IGxConfirms : public COleDispatchDriver
{
public:
	IGxConfirms() {}		// Calls COleDispatchDriver default constructor
	IGxConfirms(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxConfirms(const IGxConfirms& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxConfirmEvents wrapper class

class IGxConfirmEvents : public COleDispatchDriver
{
public:
	IGxConfirmEvents() {}		// Calls COleDispatchDriver default constructor
	IGxConfirmEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxConfirmEvents(const IGxConfirmEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnNewConfirm(LPDISPATCH aGxConfirm);
};
/////////////////////////////////////////////////////////////////////////////
// IGxConfirm wrapper class

class IGxConfirm : public COleDispatchDriver
{
public:
	IGxConfirm() {}		// Calls COleDispatchDriver default constructor
	IGxConfirm(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxConfirm(const IGxConfirm& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetOrder();
	double GetArrivedTime();
	long GetReqQty();
	long GetConfirmQty();
	double GetConfirmPrice();
	long GetPriceType();
	CString GetRjtReason();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxOrderHandler wrapper class

class IGxOrderHandler : public COleDispatchDriver
{
public:
	IGxOrderHandler() {}		// Calls COleDispatchDriver default constructor
	IGxOrderHandler(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOrderHandler(const IGxOrderHandler& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetOrderReqs();
	long GetWaitCount();
	CString GetLastMessage();
	LPDISPATCH PutNewOrder(LPCTSTR stAccount, LPCTSTR stSymbol, long PositionType, long PriceType, long iQty, double dPrice);
	LPDISPATCH PutChangeOrder(LPDISPATCH aTargetOrder, long iChangeQty, long PriceType, double dPrice);
	LPDISPATCH PutCancelOrder(LPDISPATCH aTargetOrder, long iCancelQty);
	void Send();
	LPDISPATCH PutNewOrder2(LPCTSTR stAccount, LPCTSTR stSymbol, long PositionType, long PriceType, long iQty, double dPrice, long FillType);
	LPDISPATCH PutChangeOrder2(LPDISPATCH aTargetOrder, long iChangeQty, long PriceType, double dPrice, long FillType);
};
/////////////////////////////////////////////////////////////////////////////
// IGxOrderHandlerEvents wrapper class

class IGxOrderHandlerEvents : public COleDispatchDriver
{
public:
	IGxOrderHandlerEvents() {}		// Calls COleDispatchDriver default constructor
	IGxOrderHandlerEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOrderHandlerEvents(const IGxOrderHandlerEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnStateChanged(LPDISPATCH aGxOrderReq);
};
/////////////////////////////////////////////////////////////////////////////
// IGxOrderReqs wrapper class

class IGxOrderReqs : public COleDispatchDriver
{
public:
	IGxOrderReqs() {}		// Calls COleDispatchDriver default constructor
	IGxOrderReqs(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOrderReqs(const IGxOrderReqs& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxOrderReq wrapper class

class IGxOrderReq : public COleDispatchDriver
{
public:
	IGxOrderReq() {}		// Calls COleDispatchDriver default constructor
	IGxOrderReq(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxOrderReq(const IGxOrderReq& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetAccount();
	LPDISPATCH GetSymbol();
	long GetPositionType();
	long GetPriceType();
	long GetQty();
	double GetPrice();
	LPDISPATCH GetTargetOrder();
	long GetOrderType();
	long GetState();
	long GetSrvAcptNo();
	CString GetRjtReason();
	BOOL GetIsDone();
	BOOL GetIsDoing();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxEmHandler wrapper class

class IGxEmHandler : public COleDispatchDriver
{
public:
	IGxEmHandler() {}		// Calls COleDispatchDriver default constructor
	IGxEmHandler(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxEmHandler(const IGxEmHandler& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	CString GetLastMessage();
	BOOL SendEmNewOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long PositionType, long PriceType, long iQty, double dPrice);
	BOOL SendEmChangeOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iSrvAcptNo, long iQty, long PriceType, double dPrice);
	BOOL SendEmCancelOrder(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iSrvAcptNo, long iQty);
	BOOL SendEmNewOrder2(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long PositionType, long PriceType, long iQty, double dPrice, long FillType);
	BOOL SendEmChangeOrder2(LPCTSTR stAccountCode, LPCTSTR stSymbolCode, long iSrvAcptNo, long iQty, long PriceType, double dPrice, long FillType);
};
/////////////////////////////////////////////////////////////////////////////
// IGxEmHandlerEvents wrapper class

class IGxEmHandlerEvents : public COleDispatchDriver
{
public:
	IGxEmHandlerEvents() {}		// Calls COleDispatchDriver default constructor
	IGxEmHandlerEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxEmHandlerEvents(const IGxEmHandlerEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnEmOrderArrived(long OrderType, BOOL bSuccess, long iSrvAcptNo, LPCTSTR stMsg);
};
/////////////////////////////////////////////////////////////////////////////
// IGxChartStore wrapper class

class IGxChartStore : public COleDispatchDriver
{
public:
	IGxChartStore() {}		// Calls COleDispatchDriver default constructor
	IGxChartStore(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxChartStore(const IGxChartStore& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
	LPDISPATCH Add();
	BOOL Remove(long Index);
	BOOL RemoveBySerialNo(long iSerialNo);
	BOOL GetUpdateEventFiltered();
	void SetUpdateEventFiltered(BOOL bNewValue);
	long GetUpdateEventInterval();
	void SetUpdateEventInterval(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// IGxChartData wrapper class

class IGxChartData : public COleDispatchDriver
{
public:
	IGxChartData() {}		// Calls COleDispatchDriver default constructor
	IGxChartData(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxChartData(const IGxChartData& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetSymbol();
	long GetDataType();
	long GetBase();
	long GetPeriod();
	long GetDataCount();
	LPDISPATCH GetTerms();
	BOOL GetReady();
	BOOL GetRequesting();
	long GetSerialNo();
	CString GetLastMessage();
	BOOL Define(LPCTSTR stSymbolCode, long DataType, long Base, long iPeriod, long iCount);
	void UnDefine();
};
/////////////////////////////////////////////////////////////////////////////
// IGxChartDataEvents wrapper class

class IGxChartDataEvents : public COleDispatchDriver
{
public:
	IGxChartDataEvents() {}		// Calls COleDispatchDriver default constructor
	IGxChartDataEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxChartDataEvents(const IGxChartDataEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnDataRefreshed(LPDISPATCH aGxChartData);
	void OnDataAdded(LPDISPATCH aGxChartData);
	void OnDataUpdated(LPDISPATCH aGxChartData);
};
/////////////////////////////////////////////////////////////////////////////
// IGxTerms wrapper class

class IGxTerms : public COleDispatchDriver
{
public:
	IGxTerms() {}		// Calls COleDispatchDriver default constructor
	IGxTerms(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxTerms(const IGxTerms& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	LPDISPATCH GetItem(const VARIANT& Index);
	long GetCount();
	CString GetLastMessage();
};
/////////////////////////////////////////////////////////////////////////////
// IGxTerm wrapper class

class IGxTerm : public COleDispatchDriver
{
public:
	IGxTerm() {}		// Calls COleDispatchDriver default constructor
	IGxTerm(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IGxTerm(const IGxTerm& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	double GetStartTime();
	double GetLastTime();
	double GetOpen();
	double GetHigh();
	double GetLow();
	double GetClose();
	double GetVolume();
	double GetAccVolume();
	double GetOpenInterest();
	CString GetLastMessage();
};
